home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / FGCE100.ZIP / fgce.pas < prev    next >
Pascal/Delphi Source File  |  1994-11-18  |  29KB  |  804 lines
  1. {*************************************************}
  2. {*                  FGCE.PAS 1.00                *}
  3. {*     Copyright (c) 1994 by Thomas Bargholz     *}
  4. {*             All rights reserved               *}
  5. {*************************************************}
  6. {
  7.  
  8. Fastgraph Cursor Editor. Version 1.00.
  9.  
  10. The Fastgraph name is a registered trademark of Ted Gruber Software, Inc.
  11. Used under kind permission.
  12.  
  13. This program is a mouse-cursor drawing program, that allows you to draw the
  14. appearance of the desired cursor, test it, and then save it as source code
  15. in the language of your choice.
  16.  
  17. The program requires EGA and a mouse.
  18.  
  19. Language : Borland Pascal 7.01.
  20. Date     : November 5th, 1994.
  21.  
  22. This program requires Ted Gruber Software's Fastgraph (tm) graphics library
  23. to recompile.
  24. If you're looking for a good graphics library with support for video modes
  25. from 320x200x2 to 1024x768x256, with support for PCX, GIF and FLI, lots of
  26. animation features, mouse and joy-stick support and much much more, 
  27. Fastgraph (tm) is the library for you... For more information contact:
  28.  
  29. Ted Gruber Software
  30. P.O.Box 13408
  31. Las Vegas, NV 89112
  32. USA
  33. Phone: +1 702-735-1980
  34. Fax: +1 602-483-0193
  35. CIS: 72000,1642
  36.  
  37.  
  38. If you have any suggestions, comments or bug-reports conserning this program,
  39. please contact:
  40.  
  41. e-mail     : tba@m.dia.dk
  42. snail mail : Thomas Bargholz
  43.              Smallegade 20A, 3 tv
  44.              DK-2000 Frederiksberg
  45.              Denmark
  46.  
  47. Do not contact Ted Gruber Software about this program, as they are not 
  48. responsible for it.
  49.  
  50. }
  51.  
  52.  
  53. {$DEFINE DEBUG}
  54.  
  55. {$IFDEF DEBUG}
  56. {$I-,D+,L+,Y+,A+,X+,R+,G-}
  57. {$ELSE}
  58. {$I-,D-,L-,Y-,A+,X+,R-,G-}
  59. {$ENDIF}
  60.  
  61. Uses
  62.   FgMain,                         {main graphic initialization unit}
  63.   FgMisc,                         {misc. routines unit: keyboard e.t.c}
  64.   FgBitmap;                       {bitmap drawing unit}
  65.  
  66. Const
  67.   Wait : Array[0..31] Of Word = (            {hour-glass cursor}
  68.          $001F,$803F,$803F,$803F,$803F,$C07F,$E0FF,$F1FF,
  69.          $F1FF,$E0FF,$C07F,$803F,$803F,$803F,$803F,$001F,
  70.          $0000,$3F80,$3F80,$3F80,$3B80,$1500,$0A00,$0400,
  71.          $0400,$0E00,$1B00,$3F80,$3B80,$3580,$2A80,$0000);
  72.  
  73. Type
  74.   ButtonType = (Up, Dn);                     {button type}
  75.   RadioType = (Sel, NotSel);                 {radio button type}
  76.   OutputType = (c, Pascal, Fortran, Basic);  {source code language}
  77.   TColor = (Black, White, Transp, Invert);   {cursor color}
  78.   WBit = 0..15;                              {bits in a Word}
  79.  
  80. Const
  81.   Output : OutputType = Pascal;              {default output}
  82.   Color : TColor = Black;                    {default cursor color}
  83.  
  84. Const
  85.   OutputName : String = 'CURSOR';            {default output file name}
  86.  
  87. Var
  88.   F : Text;                                  {output when saving source code}
  89.   FullCursor : Array[0..15,0..15] Of TColor; {keep track of the appearance}
  90.   Cursor : Array[0..31] Of Word;             {actual code for cursor}
  91.  
  92.  
  93. Procedure Button(State : ButtonType; PosX, PosY, Width : Integer;
  94.                  Text : String);
  95.   {- draws a button at location PosX, PosY, with the length Width,
  96.      displaying the text Text. State is either Up or Dn}
  97. Var
  98.   Len : Integer;
  99. Begin
  100.   Len := Length(Text);
  101.   Case State Of
  102.     Up : Begin
  103.            fg_move(PosX, PosY);
  104.            fg_setcolor(15);
  105.            fg_drawrel(Width,0);
  106.            fg_setcolor(8);
  107.            fg_drawrel(0,12);
  108.            fg_drawrel(-Width,0);
  109.            fg_setcolor(15);
  110.            fg_drawrel(0,-12);
  111.            fg_setcolor(7);
  112.            fg_rect(PosX+2, PosX+8+Len*8,PosY+2, PosY+10);
  113.            fg_setcolor(0);
  114.            fg_move(PosX + 8, PosY + 10);
  115.            fg_print(Text, Len);
  116.          End;
  117.     Dn : Begin
  118.            fg_move(PosX, PosY);
  119.            fg_setcolor(8);
  120.            fg_drawrel(Width,0);
  121.            fg_setcolor(15);
  122.            fg_drawrel(0,12);
  123.            fg_drawrel(-Width,0);
  124.            fg_setcolor(7);
  125.            fg_rect(PosX+2, PosX+8+Len*8,PosY+2, PosY+10);
  126.            fg_setcolor(8);
  127.            fg_drawrel(0,-12);
  128.            fg_move(PosX + 9, PosY + 11);
  129.            fg_setcolor(0);
  130.            fg_print(Text, Len);
  131.          End;
  132.   End;
  133. End;
  134.  
  135. Procedure RadioButton(State : RadioType; PosX, PosY : Integer;
  136.                       Text : String);
  137.   {- draws a radio button at location PosX, PosY, with the text Text.
  138.      State is either Sel or NotSel (selected/not selcted)}
  139. Var
  140.   Len : Integer;
  141. Begin
  142.   Len := Length(Text);
  143.   Case State Of
  144.     Sel : Begin
  145.             fg_setcolor(0);
  146.             fg_move(PosX+5,PosY+5);
  147.             fg_circle(5);
  148.             fg_circlef(3);
  149.             fg_move(PosX + 17, PosY + 9);
  150.             fg_print(Text,Len);
  151.           End;
  152.     NotSel : Begin
  153.                fg_setcolor(0);
  154.                fg_move(PosX+5,PosY+5);
  155.                fg_circle(5);
  156.                fg_setcolor(7);
  157.                fg_circlef(3);
  158.                fg_move(PosX + 17, PosY + 9);
  159.                fg_setcolor(0);
  160.                fg_print(Text,Len);
  161.              End;
  162.   End;
  163. End;
  164.  
  165. Procedure GroupBox(X,Y,Width,Height : Integer; Text : String);
  166.   {- draws a group box, with upper left corner in position X,Y and
  167.      with the width Width, and the height Height. Text is the group
  168.      box caption}
  169. Var
  170.   Len : Integer;
  171. Begin
  172.   Len := Length(Text);
  173.   fg_move(X,Y);
  174.   fg_setcolor(8);
  175.   fg_drawrel(Width,0);
  176.   fg_setcolor(15);
  177.   fg_drawrel(0,Height);
  178.   fg_drawrel(-Width,0);
  179.   fg_setcolor(8);
  180.   fg_drawrel(0,-Height);
  181.   fg_setcolor(7);
  182.   fg_rect(X+3,X+6+Len*8,Y-4,Y+4);
  183.   fg_setcolor(0);
  184.   fg_move(X+6,Y+3);
  185.   fg_print(Text,Len);
  186. End;
  187.  
  188. Procedure DrawGrid;
  189.   {- draw grid for the fat bit editor}
  190. Begin
  191.   fg_setcolor(7);
  192.   fg_rect(110,206,30,126);                       {clear area for grid}
  193.   fg_setcolor(8);
  194.   fg_move(110,30); fg_drawrel(96,0);             {draw the lines that make }
  195.   fg_move(110,36); fg_drawrel(96,0);             {up the grid              }
  196.   fg_move(110,42); fg_drawrel(96,0);
  197.   fg_move(110,48); fg_drawrel(96,0);
  198.   fg_move(110,54); fg_drawrel(96,0);
  199.   fg_move(110,60); fg_drawrel(96,0);
  200.   fg_move(110,66); fg_drawrel(96,0);
  201.   fg_move(110,72); fg_drawrel(96,0);
  202.   fg_move(110,78); fg_drawrel(96,0);
  203.   fg_move(110,84); fg_drawrel(96,0);
  204.   fg_move(110,90); fg_drawrel(96,0);
  205.   fg_move(110,96); fg_drawrel(96,0);
  206.   fg_move(110,102);fg_drawrel(96,0);
  207.   fg_move(110,108);fg_drawrel(96,0);
  208.   fg_move(110,114);fg_drawrel(96,0);
  209.   fg_move(110,120);fg_drawrel(96,0);
  210.   fg_move(110,126);fg_drawrel(96,0);
  211.   fg_move(110,30); fg_drawrel(0,96);
  212.   fg_move(116,30); fg_drawrel(0,96);
  213.   fg_move(122,30); fg_drawrel(0,96);
  214.   fg_move(128,30); fg_drawrel(0,96);
  215.   fg_move(134,30); fg_drawrel(0,96);
  216.   fg_move(140,30); fg_drawrel(0,96);
  217.   fg_move(146,30); fg_drawrel(0,96);
  218.   fg_move(152,30); fg_drawrel(0,96);
  219.   fg_move(158,30); fg_drawrel(0,96);
  220.   fg_move(164,30); fg_drawrel(0,96);
  221.   fg_move(170,30); fg_drawrel(0,96);
  222.   fg_move(176,30); fg_drawrel(0,96);
  223.   fg_move(182,30); fg_drawrel(0,96);
  224.   fg_move(188,30); fg_drawrel(0,96);
  225.   fg_move(194,30); fg_drawrel(0,96);
  226.   fg_move(200,30); fg_drawrel(0,96);
  227.   fg_move(206,30); fg_drawrel(0,96);
  228. End;
  229.  
  230. Procedure BuildUI;
  231.   {- create the user interface}
  232. Begin
  233.   fg_setcolor(15);
  234.   fg_rect(0,fg_getmaxx,0,12);                    {top line}
  235.   fg_rect(0,fg_getmaxx,fg_getmaxy-12,fg_getmaxy);{bottom line}
  236.   fg_setcolor(7);
  237.   fg_rect(0,fg_getmaxx,13,fg_getmaxy-13);        {work area}
  238.   fg_setcolor(0);
  239.   fg_move(6,11);
  240.   fg_print('Fastgraph Cursor Editor 1.00',28);   {name in black at top}
  241.   fg_move(6,198);
  242.   fg_print('Source code : ',14);                 {name in black at bottom}
  243.   fg_move(120,197);
  244.   fg_print('CURSOR.PAS',10);                     {default output name}
  245.   fg_setcolor(12);
  246.   fg_move(5,10);
  247.   fg_print('Fastgraph Cursor Editor 1.00',28);   {name in red at top}
  248.   fg_move(5,197);
  249.   fg_print('Source code : ',14);                 {name in red at bottom}
  250.   Button(Up,5,20,56,'Save');                     {"Save" - button}
  251.   Button(Up,5,35,56,'Clear');                    {"Clear" - button}
  252.   Button(Up,5,50,56,'Test');                     {"Test" - button}
  253.   Button(Up,5,65,56,'Exit');                     {"Exit" - button}
  254.   RadioButton(Sel,7,130,'Pascal');               {"Pascal" - radio button}
  255.   RadioButton(NotSel,7,142,'c');                 {"c" - radio button}
  256.   RadioButton(NotSel,7,154,'Fortran');           {"Fortran" - radio button}
  257.   RadioButton(NotSel,7,166,'Basic');             {"Basic" - radio button}
  258.   GroupBox(3,125,80,55,'Source');                {group box for above radio}
  259.   RadioButton(Sel,236,130,'Black');              {"Black" - radio button}
  260.   RadioButton(NotSel,236,142,'White');           {"White" - radio button}
  261.   RadioButton(NotSel,236,154,'Transp');          {"Transp" - radio button}
  262.   RadioButton(NotSel,236,166,'Invert');          {"Invert" - radio button}
  263.   GroupBox(232,125,80,55,'Color');               {group box for above radio}
  264.   DrawGrid;
  265.   GroupBox(90,20,135,125,'Fat');                 {group box for fat bit}
  266.   GroupBox(255,20,42,45,'Life');                 {group box for real size}
  267.   fg_mousevis(1);
  268. End;
  269.  
  270. Function HexWord(W : Word) : String;
  271.   {- converts a Word into a hex string}
  272. Const
  273.   Digits : Array[0..$F] Of Char = '0123456789ABCDEF';
  274. Begin
  275.   HexWord[0] := #4;
  276.   HexWord[1] := Digits[Hi(W) Shr 4];
  277.   HexWord[2] := Digits[Hi(W) And $F];
  278.   HexWord[3] := Digits[Lo(W) Shr 4];
  279.   HexWord[4] := Digits[Lo(W) And $F];
  280. End;
  281.  
  282. Procedure SavePas;
  283.   {- save cursor as Pascal source code}
  284. Var
  285.   I : Integer;
  286. Begin
  287.   Assign(F,OutputName + '.PAS');
  288.   Rewrite(F);
  289.   WriteLn(F);
  290.   WriteLn(F,'const');
  291.   WriteLn(F,'  MyCursor : array[0..31] of Word = (');
  292.   Write(F,'         ');
  293.   For I := 0 To 7 Do
  294.     Write(F,'$',HexWord(Cursor[I]),',');
  295.   WriteLn(F);
  296.   Write(F,'         ');
  297.   For I := 8 To 15 Do
  298.     Write(F,'$',HexWord(Cursor[I]),',');
  299.   WriteLn(F);
  300.   Write(F,'         ');
  301.   For I := 16 To 23 Do
  302.     Write(F,'$',HexWord(Cursor[I]),',');
  303.   WriteLn(F);
  304.   Write(F,'         ');
  305.   For I := 24 To 30 Do
  306.     Write(F,'$',HexWord(Cursor[I]),',');
  307.   WriteLn(F,'$',HexWord(Cursor[31]),');');
  308.   WriteLn(F);
  309.   Close(F);
  310. End;
  311.  
  312. Procedure SaveC;
  313.   {- save cursor as c source code}
  314. Var
  315.   I : Integer;
  316. Begin
  317.   Assign(F,OutputName + '.C');
  318.   Rewrite(F);
  319.   WriteLn(F);
  320.   Write(F,'short mycursor[] = {');
  321.   For I := 0 To 7 Do
  322.     Write(F,'0x',HexWord(Cursor[I]),',');
  323.   WriteLn(F);
  324.   Write(F,'                    ');
  325.   For I := 8 To 15 Do
  326.     Write(F,'0x',HexWord(Cursor[I]),',');
  327.   WriteLn(F);
  328.   Write(F,'                    ');
  329.   For I := 16 To 23 Do
  330.     Write(F,'0x',HexWord(Cursor[I]),',');
  331.   WriteLn(F);
  332.   Write(F,'                    ');
  333.   For I := 24 To 30 Do
  334.     Write(F,'0x',HexWord(Cursor[I]),',');
  335.   WriteLn(F,'0x',HexWord(Cursor[31]),'};');
  336.   WriteLn(F);
  337.   Close(F);
  338. End;
  339.  
  340. Procedure SaveFor;
  341.   {- save cursor as Fortran source code}
  342. Var
  343.   I : Integer;
  344. Begin
  345.   Assign(F,OutputName + '.FOR');
  346.   Rewrite(F);
  347.   WriteLn(F);
  348.   WriteLn(F,'       INTEGER*2 MYCURSOR(32)');
  349.   WriteLn(F);
  350.   WriteLn(F,'       DATA MYCURSOR /');
  351.   Write(F,'      +   ');
  352.   For I := 0 To 7 Do
  353.     Write(F,'#',HexWord(Cursor[I]),',');
  354.   WriteLn(F);
  355.   Write(F,'      +   ');
  356.   For I := 8 To 15 Do
  357.     Write(F,'#',HexWord(Cursor[I]),',');
  358.   WriteLn(F);
  359.   Write(F,'      +   ');
  360.   For I := 16 To 23 Do
  361.     Write(F,'#',HexWord(Cursor[I]),',');
  362.   WriteLn(F);
  363.   Write(F,'      +   ');
  364.   For I := 24 To 30 Do
  365.     Write(F,'#',HexWord(Cursor[I]),',');
  366.   WriteLn(F,'#',HexWord(Cursor[31]),'/');
  367.   WriteLn(F);
  368.   Close(F);
  369. End;
  370.  
  371. Procedure SaveBas;
  372.   {- save cursor as Baic source code}
  373. Var
  374.   I : Integer;
  375. Begin
  376.   Assign(F,OutputName + '.BAS');
  377.   Rewrite(F);
  378.   WriteLn(F);
  379.   WriteLn(F,'DIM MyCursor(32)');
  380.   WriteLn(F);
  381.   WriteLn(F,'Rem MyCursor values');
  382.   Write(F,'DATA ');
  383.   For I := 0 To 7 Do
  384.     Write(F,'&',HexWord(Cursor[I]),',');
  385.   WriteLn(F);
  386.   Write(F,'DATA ');
  387.   For I := 8 To 15 Do
  388.     Write(F,'&',HexWord(Cursor[I]),',');
  389.   WriteLn(F);
  390.   Write(F,'DATA ');
  391.   For I := 16 To 23 Do
  392.     Write(F,'&',HexWord(Cursor[I]),',');
  393.   WriteLn(F);
  394.   Write(F,'DATA ');
  395.   For I := 24 To 30 Do
  396.     Write(F,'&',HexWord(Cursor[I]),',');
  397.   WriteLn(F,'&',HexWord(Cursor[31]));
  398.   WriteLn(F);
  399.   Close(F);
  400. End;
  401.  
  402.  
  403. Procedure CalcCursor;
  404.   {- calculates the word values for the actual cursor}
  405.  
  406.   Procedure SetBitW(Var W : Word; Bit : WBit);Assembler;
  407.     {- set specified bit in a Word}
  408.   Asm
  409.     Mov Cl, Bit
  410.     Mov BX, 1
  411.     SHL BX, CL
  412.     LES DI, W
  413.     OR ES:[DI], BX
  414.   End;
  415.  
  416. Var
  417.   I, J : Integer;
  418. Begin
  419.   FillChar(Cursor,SizeOf(Cursor),0);             {solid black as default,
  420.                                                   as no bits are set}
  421.   For I := 0 To 15 Do
  422.     For J := 0 To 15 Do
  423.       Case FullCursor[I,J] Of
  424.         White : SetBitW(Cursor[J+16],15-I);      {set the bits for white}
  425.         Transp : SetBitW(Cursor[J],15-I);        {set the bits for transp.}
  426.         Invert : Begin                           {set the bits for inverted}
  427.                    SetBitW(Cursor[J+16],15-I);
  428.                    SetBitW(Cursor[J],15-I);
  429.                  End;
  430.       End;
  431. End;
  432.  
  433.  
  434. Var
  435.   OldMode : Byte;                                {stores the old video mode}
  436.   Count, X, Y : Integer;                         {track mouse}
  437.   Bt, PosX, PosY : Integer;                      {  -- " -- }
  438.   TileX, TileY : Integer;                        {position in fat bit editor}
  439.   key, aux : Byte;                               {keyboard scan codes}
  440.   Ch : Char;                                     {keyboard pressed chararacter}
  441.   S : String;                                    {filename as a string}
  442.   I : Integer;                                   {length of filename}
  443.  
  444. Begin
  445.   OldMode := fg_getmode;                         {save old video mode}
  446.   If fg_testmode(13,1) = 0 Then                  {hardware ok?}
  447.   Begin
  448.     fg_setmode(OldMode);
  449.     fg_reset;
  450.     WriteLn('What a piece of crap hardware you got!');
  451.     Halt(1);
  452.   End;
  453.   fg_setmode(13);                                {320x200 EGA graphic mode}
  454.   if (fg_mouseini < 0) then                      {is a mouse present?}
  455.   begin
  456.     fg_setmode(OldMode);
  457.     fg_reset;
  458.     WriteLn('Sorry! Fastgraph Cursor Editor requires a rodent');
  459.     Halt(1);
  460.   end;
  461.  
  462.   FillChar(FullCursor,SizeOf(FullCursor),Transp);{work area is transparent}
  463.  
  464.   BuildUI;                                       {create the user interface}
  465.  
  466.   Repeat                                         {loop while checking mouse}
  467.     fg_mousebut(-1,Count,PosX,PosY);             {left mouse button release}
  468.     fg_mousebut(1,Count,X,Y);                    {left mouse button press}
  469.     If (X = 0) And (Y = 0) Then Continue;
  470.     If (X >= 6) And (X <= 60) And (Y In [21..31]) Then
  471.     Begin                                        {mouse press : Save button}
  472.       fg_mousevis(0);
  473.       Button(Dn,5,20,56,'Save');                 {draw pressed button}
  474.       fg_mousevis(1);
  475.       Repeat
  476.         fg_mousebut(-1,Count,X,Y);               {wait for a mouse release}
  477.       Until Count > 0;
  478.       If (X >= 6) And (X <= 60) And (Y In [21..31]) Then
  479.       Begin                                      {relase inside button}
  480.         fg_mouseptr(Wait,6,8);                   {use hour-glass cursor}
  481.         CalcCursor;                              {calculate data for cursor}
  482.         Case Output Of                           {save correct source code}
  483.           Pascal : SavePas;
  484.           c : SaveC;
  485.           Fortran : SaveFor;
  486.           Basic : SaveBas;
  487.         End;
  488.         fg_mousepos(PosX, PosY, Bt);             {get mouse position}
  489.         fg_mouseini;                             {reset mouse cursor}
  490.         fg_mousemov(PosX, PosY);                 {set mouse position}
  491.       End;
  492.       fg_mousevis(0);
  493.       Button(Up,5,20,56,'Save');                 {redraw button}
  494.       fg_mousevis(1);
  495.       Continue;
  496.     End;
  497.     If (X >= 6) And (X <= 60) And (Y In [36..46]) Then
  498.     Begin                                        {mouse press : Clear button}
  499.       fg_mousevis(0);
  500.       Button(Dn,5,35,56,'Clear');                {draw pressed button}
  501.       fg_mousevis(1);
  502.       Repeat
  503.         fg_mousebut(-1,Count,X,Y);               {wait for mouse release}
  504.       Until Count > 0;
  505.       If (X >= 6) And (X <= 60) And (Y In [36..46]) Then
  506.       Begin                                      {release inside button}
  507.         FillChar(FullCursor,SizeOf(FullCursor),Transp);{reset data structure}
  508.         fg_mousevis(0);
  509.         DrawGrid;                                {reset grid}
  510.         fg_setcolor(7);
  511.         fg_rect(265,290,35,60);                  {reset life size area}
  512.         fg_mousevis(1);
  513.       End;
  514.       fg_mousevis(0);
  515.       Button(Up,5,35,56,'Clear');                {redraw button}
  516.       fg_mousevis(1);
  517.       Continue;
  518.     End;
  519.     If (X >= 6) And (X <= 60) And (Y In [51..61]) Then
  520.     Begin                                        {mouse press : Test button}
  521.       fg_mousevis(0);
  522.       Button(Dn,5,50,56,'Test');                 {draw pressed button}
  523.       fg_mousevis(1);
  524.       Repeat                                     {wait for a mouse release}
  525.         fg_mousebut(-1,Count,PosX,PosY);
  526.       Until Count > 0;
  527.       If (PosX >= 6) And (PosX <= 60) And (PosY In [51..61]) Then
  528.       Begin                                      {released inside button}
  529.         CalcCursor;                              {calculate data for cursor}
  530.         fg_mouseptr(Cursor,0,0);
  531.         Repeat
  532.           fg_mousebut(1,Count,PosX,PosY);        {wait for a mouse press}
  533.         Until Count > 0;
  534.         Repeat
  535.           fg_mousebut(-1,Count,PosX,PosY);       {wait for mouse release}
  536.         Until Count > 0;
  537.         fg_mousepos(PosX, PosY, Bt);             {get mouse position}
  538.         fg_mouseini;                             {reset mouse cursor}
  539.         fg_mousemov(PosX, PosY);                 {set mouse position}
  540.       End;
  541.       Button(Up,5,50,56,'Test');                 {redraw button}
  542.       fg_mousevis(1);
  543.       Continue;
  544.     End;
  545.     If (X >= 6) And (X <= 60) And (Y In [66..76]) Then
  546.     Begin                                        {mouse press : Exit button}
  547.       fg_mousevis(0);
  548.       Button(Dn,5,65,56,'Exit');                 {draw pressed button}
  549.       fg_mousevis(1);
  550.       Repeat
  551.         fg_mousebut(-1,Count,X,Y);               {wait for mouse release}
  552.       Until Count > 0;
  553.       If (X >= 6) And (X <= 60) And (Y In [66..76]) Then
  554.         Break;                                   {released inside button}
  555.       fg_mousevis(0);
  556.       Button(Up,5,65,56,'Exit');                 {redraw button}
  557.       fg_mousevis(1);
  558.       Continue;
  559.     End;
  560.     If (X >= 5) And (X <= 75) And (Y In [130..140]) Then
  561.     Begin                                        {mouse press : Pascal radiobt}
  562.       If Output <> Pascal Then
  563.       Begin
  564.         fg_mousevis(0);
  565.         RadioButton(Sel,7,130,'Pascal');         {redraw radio buttons}
  566.         RadioButton(NotSel,7,142,'c');
  567.         RadioButton(NotSel,7,154,'Fortran');
  568.         RadioButton(NotSel,7,166,'Basic');
  569.         Output := Pascal;                        {new selected output type}
  570.         fg_setcolor(15);
  571.         fg_rect(118,220,189,198);                {erase filename in status}
  572.         fg_setcolor(0);
  573.         fg_move(120,197);
  574.         fg_print(OutputName + '.PAS',Length(OutputName)+4);{new filename}
  575.         fg_mousevis(1);
  576.         Continue;
  577.       End;
  578.     End;
  579.     If (X >= 5) And (X <= 75) And (Y In [142..152]) Then
  580.     Begin                                        {mouse press : c radiobt}
  581.       If Output <> c Then
  582.       Begin
  583.         fg_mousevis(0);
  584.         RadioButton(NotSel,7,130,'Pascal');      {redraw radio buttons}
  585.         RadioButton(Sel,7,142,'c');
  586.         RadioButton(NotSel,7,154,'Fortran');
  587.         RadioButton(NotSel,7,166,'Basic');
  588.         Output := c;                             {new selected output type}
  589.         fg_setcolor(15);
  590.         fg_rect(118,220,189,198);                {erase filename in status}
  591.         fg_setcolor(0);
  592.         fg_move(120,197);
  593.         fg_print(OutputName + '.C',Length(OutputName)+2);{new filename}
  594.         fg_mousevis(1);
  595.         Continue;
  596.       End;
  597.     End;
  598.     If (X >= 5) And (X <= 75) And (Y In [154..164]) Then
  599.     Begin                                        {mouse press : Fortran radio}
  600.       If Output <> Fortran Then
  601.       Begin
  602.         fg_mousevis(0);
  603.         RadioButton(NotSel,7,130,'Pascal');      {redraw radio buttons}
  604.         RadioButton(NotSel,7,142,'c');
  605.         RadioButton(Sel,7,154,'Fortran');
  606.         RadioButton(NotSel,7,166,'Basic');
  607.         Output := Fortran;                       {new selected output type}
  608.         fg_setcolor(15);
  609.         fg_rect(118,220,189,198);                {erase filename in status}
  610.         fg_setcolor(0);
  611.         fg_move(120,197);
  612.         fg_print(OutputName + '.FOR',Length(OutputName)+4);{new filename}
  613.         fg_mousevis(1);
  614.         Continue;
  615.       End;
  616.     End;
  617.     If (X >= 5) And (X <= 75) And (Y In [166..176]) Then
  618.     Begin                                        {mouse press : Basic radiobt}
  619.       If Output <> Basic Then
  620.       Begin
  621.         fg_mousevis(0);
  622.         RadioButton(NotSel,7,130,'Pascal');      {redraw radio buttons}
  623.         RadioButton(NotSel,7,142,'c');
  624.         RadioButton(NotSel,7,154,'Fortran');
  625.         RadioButton(Sel,7,166,'Basic');
  626.         Output := Basic;                         {set new output type}
  627.         fg_setcolor(15);
  628.         fg_rect(118,220,189,198);                {erase filename in status}
  629.         fg_setcolor(0);
  630.         fg_move(120,197);
  631.         fg_print(OutputName + '.BAS',Length(OutputName)+4);{new filename}
  632.         fg_mousevis(1);
  633.         Continue;
  634.       End;
  635.     End;
  636.     If (X >= 236) And (X <= 308) And (Y In [130..140]) Then
  637.     Begin                                        {mouse press : Black radiobt}
  638.       If Color <> Black Then
  639.       Begin
  640.         fg_mousevis(0);
  641.         RadioButton(Sel,236,130,'Black');        {redraw radio buttons}
  642.         RadioButton(NotSel,236,142,'White');
  643.         RadioButton(NotSel,236,154,'Transp');
  644.         RadioButton(NotSel,236,166,'Invert');
  645.         fg_mousevis(1);
  646.         Color := Black;                          {set new color type}
  647.         Continue;
  648.       End;
  649.     End;
  650.     If (X >= 238) And (X <= 308) And (Y In [142..152]) Then
  651.     Begin                                        {mouse press : White radiobt}
  652.       If Color <> White Then
  653.       Begin
  654.         fg_mousevis(0);
  655.         RadioButton(NotSel,236,130,'Black');     {redraw radio buttons}
  656.         RadioButton(Sel,236,142,'White');
  657.         RadioButton(NotSel,236,154,'Transp');
  658.         RadioButton(NotSel,236,166,'Invert');
  659.         fg_mousevis(1);
  660.         Color := White;                          {set new color type}
  661.         Continue;
  662.       End;
  663.     End;
  664.     If (X >= 238) And (X <= 308) And (Y In [154..164]) Then
  665.     Begin                                        {mouse press : Transp radiobt}
  666.       If Color <> Transp Then
  667.       Begin
  668.         fg_mousevis(0);
  669.         RadioButton(NotSel,236,130,'Black');     {redraw radio buttons}
  670.         RadioButton(NotSel,236,142,'White');
  671.         RadioButton(Sel,236,154,'Transp');
  672.         RadioButton(NotSel,236,166,'Invert');
  673.         fg_mousevis(1);
  674.         Color := Transp;                         {set new color type}
  675.         Continue;
  676.       End;
  677.     End;
  678.     If (X >= 238) And (X <= 308) And (Y In [166..176]) Then
  679.     Begin                                        {mouse press : Invert radiobt}
  680.       If Color <> Invert Then
  681.       Begin
  682.         fg_mousevis(0);
  683.         RadioButton(NotSel,236,130,'Black');     {redraw radio buttons}
  684.         RadioButton(NotSel,236,142,'White');
  685.         RadioButton(NotSel,236,154,'Transp');
  686.         RadioButton(Sel,236,166,'Invert');
  687.         fg_mousevis(1);
  688.         Color := Invert;                         {set new color type}
  689.         Continue;
  690.       End;
  691.     End;
  692.     If (X >= 118) And (X <= 214) And (Y In [180..200]) Then
  693.     Begin                                        {mouse click : filename}
  694.       fg_mousevis(0);
  695.       fg_setcolor(15);
  696.       fg_rect(118,220,189,198);                  {erase filename in status}
  697.       fg_setcolor(0);
  698.       fg_move(120,197);
  699.       fg_print('|',1);
  700.       S := '';
  701.       I := 0;
  702.       Repeat
  703.         fg_intkey(Key,Aux);                      {empty keyboard buffer}
  704.       Until (Key = 0) And (Aux = 0);
  705.       Repeat
  706.         fg_getkey(key,aux);                      {get keyboard}
  707.         Ch := UpCase(Chr(key));
  708.         If (Ch In ['0'..'9','A'..'Z',#123,#125,#95,#91,#93,#40,#41,#45]) Then
  709.            {valid keys are: 0-9,A-Z,{,_,[,],(,),- and }
  710.         Begin                                    {did we have a valid key?}
  711.           Inc(I);                                {increment char count}
  712.           If I > 8 Then
  713.             I := 8;                              {max 8 characters}
  714.           If I = 8 Then
  715.             S := Copy(S,1,7);
  716.           S := S + Ch;
  717.         End;
  718.         If Key = 8 Then                          {backspace}
  719.         Begin
  720.           If I > 1 Then
  721.           Begin
  722.             S := Copy(S,1,Length(S)-1);          {remove last char}
  723.             Dec(I);                              {decrement char count}
  724.           End
  725.           Else
  726.           Begin
  727.             I := 0;                              {not chars available}
  728.             S := '';                             {empty string}
  729.           End;
  730.         End;
  731.         If I = 8 Then                            {change only 8'th character}
  732.         Begin
  733.           fg_setcolor(15);
  734.           fg_rect(176,220,189,198);              {erase last char}
  735.           fg_setcolor(0);
  736.           fg_move(176,197);
  737.           fg_print(S[8]+'|',2);                  {write new last char}
  738.         End
  739.         Else
  740.         Begin                                    {add character}
  741.           fg_setcolor(15);
  742.           fg_rect(112 + I*8,220,189,198);
  743.           fg_setcolor(0);
  744.           fg_move(112 + I*8,197);
  745.           If S <> '' Then
  746.             fg_print(S[I]+'|',2)
  747.           Else
  748.             fg_print(' |',2);
  749.         End;
  750.       Until (key = 13) Or (key = 27);            {enter or escape}
  751.       If key = 13 Then                           {if enter was pressed, and}
  752.         If S <> '' Then                          {the user gave a new name:}
  753.           OutputName := S;                       {save it as the default   }
  754.       Case Output Of                             {add the extension}
  755.         Pascal : S := OutputName + '.PAS';
  756.         c : S := OutputName + '.C';
  757.         Fortran : S := OutputName + '.FOR';
  758.         Basic : S := OutputName + '.BAS';
  759.       End;
  760.       fg_setcolor(15);
  761.       fg_rect(118,220,189,198);                  {erase filename from status}
  762.       fg_setcolor(0);
  763.       fg_move(120,197);
  764.       fg_print(S,Length(S));                     {write the new output name}
  765.       fg_mousevis(1);
  766.       Continue;
  767.     End;
  768.     If (X >= 110) And (X <= 206) And (Y In [30..126]) Then
  769.     Begin                                        {inside the fat bit grid}
  770.       Case Color Of
  771.         Black : fg_setcolor(0);                  {set selected color}
  772.         White : fg_setcolor(15);
  773.         Transp : fg_setcolor(7);
  774.         Invert : fg_setcolor(3);
  775.       End;
  776.       PosX := 100;
  777.       Repeat
  778.         fg_mousepos(X,Y,Bt);                     {get mouse position}
  779.         TileX := (X-110) Div 6;                  {calculate X bit}
  780.         TileY := (Y-30) Div 6;                   {calculate Y bit}
  781.         If (TileX >= 0) And (TileX <= 15) And (TileY >= 0) And
  782.            (TileY <= 15) And ((TileX <> PosX) Or (TileY <> PosY)) Then
  783.         Begin                                    {mouse moved inside grid}
  784.           fg_mousevis(0);
  785.           fg_rect(111+TileX*6,115+TileX*6,31+TileY*6,35+TileY*6);{fat bit}
  786.           fg_point(269+TileX,36+TileY);          {real size cursor}
  787.           fg_mousevis(1);
  788.           FullCursor[TileX,TileY] := Color;      {update data structure}
  789.           PosX := TileX;                         {save current X bit}
  790.           PosY := TileY;                         {save current Y bit}
  791.         End;
  792.         fg_mousebut(-1,Count,X,Y);               {check if mouse was released}
  793.       Until Count > 0;
  794.       Continue;
  795.     End;
  796.   Until True = False;                            {which should last forever}
  797.  
  798.   fg_setmode(OldMode);                           {reset video mode}
  799.   fg_reset;                                      {reset Fastgraph}
  800.  
  801. End.
  802.  
  803.  
  804.